// 题意：还是差分约束，给的条件是>或者<
//
// 题解：首先要将>转为>=，<也一样，因为整数很好转换。
//       另外，图可能不联通，导致负环从给定的源点开始判不到，
//       所以可以加个超级源或者初始把所有点都推到队列中。
//
// run: time $exec < input
#include <iostream>
#include <vector>
#include <string>
#include <deque>

template <class T>
struct shortest_path_faster_algorithm
{
	typedef T value_type;
	typedef int size_type;

	struct edge {
		edge(size_type from, size_type to, value_type cost) : from(from), to(to), cost(cost) {}
		int from, to, cost;
	};

	typedef std::vector<edge> adj_edge;
	typedef typename adj_edge::iterator edge_iter;
	typedef std::vector<adj_edge> graph_type;
//	enum { inf = 1 << 28 };
	int static const inf = 1 << 28;

	shortest_path_faster_algorithm(size_type n) : n(n)
	{
		graph.resize(n);
		dist.resize(n);
		in_queue.resize(n);
		count_into_que.resize(n);
	}

	void add_edge(size_type from, size_type to, value_type cost)
	{
		graph[from].push_back(edge(from, to, cost));
	}

	value_type spfa(size_type source, size_type target)
	{
		std::fill(dist.begin(), dist.end(), +inf);
		std::fill(in_queue.begin(), in_queue.end(), false);
		std::deque<value_type> relaxed(1, source);
		dist[source] = 0;
		in_queue[source] = true;
		count_into_que[source]++;
		while (!relaxed.empty()) {
			size_type now = relaxed.front();
			in_queue[now] = false;
			relaxed.pop_front();

			for (edge_iter it = graph[now].begin(); it != graph[now].end(); ++it) {
				size_type v = it->to;
				value_type c = it->cost;
				if (dist[v] > dist[now] + c) {
					dist[v] = dist[now] + c;
					if (!in_queue[v]) {
						if (count_into_que[v] >= n) return -inf;
						if (!relaxed.empty() && dist[v] < dist[relaxed.front()])
							relaxed.push_front(v);
						else
							relaxed.push_back(v);
						in_queue[v] = true;
						count_into_que[v]++;
					}
				}
			}
		}
		return dist[target];
	}

private:
	graph_type graph;
	size_type n;
	std::vector<size_type> count_into_que;
	std::vector<value_type> dist;
	std::vector<char> in_queue; // FIXME std::vector<bool>;
};

int n, m, si, ni, ki;
std::string opt;

int main()
{
	std::ios::sync_with_stdio(false);
	while (std::cin >> n >> m && n) {
		shortest_path_faster_algorithm<int> sp(n+2);
		for (int i = 0; i <= n; i++)
			sp.add_edge(n + 1, i, 0);
		for (int i = 0; i < m; i++) {
			std::cin >> si >> ni >> opt >> ki;
			if (opt == "lt") {
				ki--;
				sp.add_edge(si + ni, si - 1, ki);
			} else {
				ki++;
				sp.add_edge(si - 1, si + ni, -ki);
			}
		}
		if (sp.spfa(n + 1, n) == -sp.inf)
			std::cout << "successful conspiracy\n";
		else
			std::cout << "lamentable kingdom\n";
	}
}

